home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / etc / RCS / getpwent.c,v < prev    next >
Encoding:
Text File  |  1990-11-27  |  9.9 KB  |  527 lines
  1. head     1.4;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.4
  10. date     90.11.27.13.07.08;  author shirriff;  state Exp;
  11. branches ;
  12. next     1.3;
  13.  
  14. 1.3
  15. date     90.07.08.16.00.22;  author shirriff;  state Exp;
  16. branches ;
  17. next     1.2;
  18.  
  19. 1.2
  20. date     90.02.23.17.09.02;  author rab;  state Exp;
  21. branches ;
  22. next     1.1;
  23.  
  24. 1.1
  25. date     88.06.26.15.15.04;  author ouster;  state Exp;
  26. branches ;
  27. next     ;
  28.  
  29.  
  30. desc
  31. @@
  32.  
  33.  
  34. 1.4
  35. log
  36. @Made some bug fix a few months ago.  Unfortunately I can't remember
  37. exactly what it did.  I think it was related to using the public
  38. or the shadow password file appropriately when running suid root.
  39. @
  40. text
  41. @/*
  42.  * Copyright (c) 1988 The Regents of the University of California.
  43.  * All rights reserved.
  44.  *
  45.  * Redistribution and use in source and binary forms are permitted
  46.  * provided that the above copyright notice and this paragraph are
  47.  * duplicated in all such forms and that any documentation,
  48.  * advertising materials, and other materials related to such
  49.  * distribution and use acknowledge that the software was developed
  50.  * by the University of California, Berkeley.  The name of the
  51.  * University may not be used to endorse or promote products derived
  52.  * from this software without specific prior written permission.
  53.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  54.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  55.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  56.  */
  57.  
  58. #if defined(LIBC_SCCS) && !defined(lint)
  59. static char sccsid[] = "@@(#)getpwent.c    5.9 (Berkeley) 4/1/89";
  60. #endif /* LIBC_SCCS and not lint */
  61.  
  62. #include <sys/types.h>
  63. #include <sys/file.h>
  64. #include <stdio.h>
  65. #include <pwd.h>
  66. #include <ndbm.h>
  67.  
  68. static DBM *_pw_db;
  69. static FILE *_pw_fp;
  70. static struct passwd _pw_passwd;
  71. static int _pw_rewind = 1, _pw_stayopen;
  72. static char _pw_flag, *_pw_file = _PATH_PASSWD;
  73. static int _pw_old = 0;        /* 1 indicates old passwd file format. */
  74.  
  75. static start_pw(), scanpw(), fetch_pw(), getpw();
  76.  
  77. #define    MAXLINELENGTH    1024
  78. static char line[MAXLINELENGTH];
  79.  
  80. struct passwd *
  81. getpwent()
  82. {
  83.     datum key;
  84.     int rval;
  85.  
  86.     if (!_pw_db && !_pw_fp && !start_pw())
  87.         return((struct passwd *)NULL);
  88.     do {
  89.         if (_pw_db) {
  90.             key.dptr = NULL;
  91.             rval = fetch_pw(key);
  92.         } else /* _pw_fp */
  93.             rval = scanpw();
  94.     } while (rval && (_pw_db && _pw_flag != _PW_KEYBYNAME));
  95.     if (rval)
  96.         getpw();
  97.     return(rval ? &_pw_passwd : (struct passwd *)NULL);
  98. }
  99.  
  100. struct passwd *
  101. getpwnam(nam)
  102.     char *nam;
  103. {
  104.     int rval;
  105.  
  106.     if (!start_pw())
  107.         return((struct passwd *)NULL);
  108.     if (_pw_db) {
  109.         datum key;
  110.  
  111.         key.dptr = nam;
  112.         key.dsize = strlen(nam);
  113.         rval = fetch_pw(key);
  114.     } else /* _pw_fp */
  115.         for (rval = 0; scanpw();)
  116.             if (!strcmp(nam, _pw_passwd.pw_name)) {
  117.                 rval = 1;
  118.                 break;
  119.             }
  120.     if (!_pw_stayopen)
  121.         endpwent();
  122.     if (rval)
  123.         getpw();
  124.     return(rval ? &_pw_passwd : (struct passwd *)NULL);
  125. }
  126.  
  127. struct passwd *
  128. getpwuid(uid)
  129.     int uid;
  130. {
  131.     int rval;
  132.  
  133.     if (!start_pw())
  134.         return((struct passwd *)NULL);
  135.     if (_pw_db) {
  136.         datum key;
  137.  
  138.         key.dptr = (char *)&uid;
  139.         key.dsize = sizeof(uid);
  140.         rval = fetch_pw(key);
  141.     } else /* _pw_fp */
  142.         for (rval = 0; scanpw();)
  143.             if (_pw_passwd.pw_uid == uid) {
  144.                 rval = 1;
  145.                 break;
  146.             }
  147.     if (!_pw_stayopen)
  148.         endpwent();
  149.     if (rval)
  150.         getpw();
  151.     return(rval ? &_pw_passwd : (struct passwd *)NULL);
  152. }
  153.  
  154. static
  155. start_pw()
  156. {
  157.     char *p;
  158.  
  159.     if (_pw_db) {
  160.         _pw_rewind = 1;
  161.         return(1);
  162.     }
  163.     if (_pw_fp) {
  164.         rewind(_pw_fp);
  165.         return(1);
  166.     }
  167.     if (_pw_db = dbm_open(_pw_file, O_RDONLY, 0))
  168.         return(1);
  169.     /*
  170.      * special case; if it's the official password file, look in
  171.      * the master password file, otherwise, look in the file itself.
  172.      * But, only look in the master file if we're root.
  173.      */
  174.     if (!strcmp(_pw_file, _PATH_PASSWD)) {
  175.         if (geteuid()) {
  176.         p = _pw_file;
  177.         _pw_old = 1;
  178.         } else {
  179.         p = _PATH_MASTERPASSWD;
  180.         }
  181.     } else {
  182.         p = _pw_file;
  183.     }
  184.     if (_pw_fp = fopen(p, "r"))
  185.         return(1);
  186.     return(0);
  187. }
  188.  
  189. setpwent()
  190. {
  191.     return(setpassent(0));
  192. }
  193.  
  194. setpassent(stayopen)
  195.     int stayopen;
  196. {
  197.     if (!start_pw())
  198.         return(0);
  199.     _pw_stayopen = stayopen;
  200.     return(1);
  201. }
  202.  
  203. void
  204. endpwent()
  205. {
  206.     if (_pw_db) {
  207.         dbm_close(_pw_db);
  208.         _pw_db = (DBM *)NULL;
  209.     } else if (_pw_fp) {
  210.         (void)fclose(_pw_fp);
  211.         _pw_fp = (FILE *)NULL;
  212.     }
  213. }
  214.  
  215. void
  216. setpwfile(file)
  217.     char *file;
  218. {
  219.     _pw_file = file;
  220. }
  221.  
  222. static
  223. scanpw()
  224. {
  225.     register char *cp;
  226.     long atol();
  227.     char *fgets(), *strsep(), *index();
  228.  
  229.     for (;;) {
  230.         if (!(fgets(line, sizeof(line), _pw_fp)))
  231.             return(0);
  232.         /* skip lines that are too big */
  233.         if (!index(line, '\n')) {
  234.             int ch;
  235.  
  236.             while ((ch = getc(_pw_fp)) != '\n' && ch != EOF)
  237.                 ;
  238.             continue;
  239.         }
  240.         _pw_passwd.pw_name = strsep(line, ":\n");
  241.         _pw_passwd.pw_passwd = strsep((char *)NULL, ":\n");
  242.         if (!(cp = strsep((char *)NULL, ":\n")))
  243.             continue;
  244.         _pw_passwd.pw_uid = atoi(cp);
  245.         if (!(cp = strsep((char *)NULL, ":\n")))
  246.             continue;
  247.         _pw_passwd.pw_gid = atoi(cp);
  248.         if (_pw_old) {
  249.             _pw_passwd.pw_class = "";
  250.             _pw_passwd.pw_change = 0;
  251.             _pw_passwd.pw_expire = 0;
  252.         } else {
  253.             _pw_passwd.pw_class = strsep((char *)NULL, ":\n");
  254.             if (!(cp = strsep((char *)NULL, ":\n")))
  255.                 continue;
  256.             _pw_passwd.pw_change = atol(cp);
  257.             if (!(cp = strsep((char *)NULL, ":\n")))
  258.             continue;
  259.             _pw_passwd.pw_expire = atol(cp);
  260.         }
  261.         _pw_passwd.pw_gecos = strsep((char *)NULL, ":\n");
  262.         _pw_passwd.pw_dir = strsep((char *)NULL, ":\n");
  263.         _pw_passwd.pw_shell = strsep((char *)NULL, ":\n");
  264.         if (!_pw_passwd.pw_shell)
  265.             continue;
  266.         return(1);
  267.     }
  268.     /* NOTREACHED */
  269. }
  270.  
  271. static
  272. fetch_pw(key)
  273.     datum key;
  274. {
  275.     register char *p, *t;
  276.  
  277.     /*
  278.      * the .dir file is LOCK_EX locked by programs that are
  279.      * renaming the various password files.
  280.      */
  281.     if (flock(dbm_dirfno(_pw_db), LOCK_SH))
  282.         return(0);
  283.     if (!key.dptr)
  284.         if (_pw_rewind) {
  285.             _pw_rewind = 0;
  286.             key = dbm_firstkey(_pw_db);
  287.         } else
  288.             key = dbm_nextkey(_pw_db);
  289.     if (key.dptr)
  290.         key = dbm_fetch(_pw_db, key);
  291.     (void)flock(dbm_dirfno(_pw_db), LOCK_UN);
  292.     if (!(p = key.dptr))
  293.         return(0);
  294.     t = line;
  295. #define    EXPAND(e)    e = t; while (*t++ = *p++);
  296.     EXPAND(_pw_passwd.pw_name);
  297.     EXPAND(_pw_passwd.pw_passwd);
  298.     bcopy(p, (char *)&_pw_passwd.pw_uid, sizeof(int));
  299.     p += sizeof(int);
  300.     bcopy(p, (char *)&_pw_passwd.pw_gid, sizeof(int));
  301.     p += sizeof(int);
  302.     bcopy(p, (char *)&_pw_passwd.pw_change, sizeof(time_t));
  303.     p += sizeof(time_t);
  304.     EXPAND(_pw_passwd.pw_class);
  305.     EXPAND(_pw_passwd.pw_gecos);
  306.     EXPAND(_pw_passwd.pw_dir);
  307.     EXPAND(_pw_passwd.pw_shell);
  308.     bcopy(p, (char *)&_pw_passwd.pw_expire, sizeof(time_t));
  309.     p += sizeof(time_t);
  310.     _pw_flag = *p;
  311.     return(1);
  312. }
  313.  
  314. static
  315. getpw()
  316. {
  317.     static char pwbuf[50];
  318.     off_t lseek();
  319.     long pos, atol();
  320.     int fd, n;
  321.     char *p;
  322.  
  323.     if (!_pw_db || geteuid())
  324.         return;
  325.     /*
  326.      * special case; if it's the official password file, look in
  327.      * the master password file, otherwise, look in the file itself.
  328.      */
  329.     p = strcmp(_pw_file, _PATH_PASSWD) ? _pw_file : _PATH_MASTERPASSWD;
  330.     if ((fd = open(p, O_RDONLY, 0)) < 0)
  331.         return;
  332.     pos = atol(_pw_passwd.pw_passwd);
  333.     if (lseek(fd, pos, L_SET) != pos)
  334.         goto bad;
  335.     if ((n = read(fd, pwbuf, sizeof(pwbuf) - 1)) < 0)
  336.         goto bad;
  337.     pwbuf[n] = '\0';
  338.     for (p = pwbuf; *p; ++p)
  339.         if (*p == ':') {
  340.             *p = '\0';
  341.             _pw_passwd.pw_passwd = pwbuf;
  342.             break;
  343.         }
  344. bad:    (void)close(fd);
  345. }
  346. @
  347.  
  348.  
  349. 1.3
  350. log
  351. @Unix version 5.9 getpwent.c
  352. @
  353. text
  354. @d33 1
  355. d35 2
  356. d54 1
  357. a54 1
  358.     } while (rval && _pw_flag != _PW_KEYBYNAME);
  359. d132 1
  360. d134 10
  361. a143 1
  362.     p = strcmp(_pw_file, _PATH_PASSWD) ? _pw_file : _PATH_MASTERPASSWD;
  363. d208 10
  364. a217 2
  365.         _pw_passwd.pw_class = strsep((char *)NULL, ":\n");
  366.         if (!(cp = strsep((char *)NULL, ":\n")))
  367. d219 2
  368. a220 4
  369.         _pw_passwd.pw_change = atol(cp);
  370.         if (!(cp = strsep((char *)NULL, ":\n")))
  371.             continue;
  372.         _pw_passwd.pw_expire = atol(cp);
  373. d283 1
  374. a283 1
  375.     if (geteuid())
  376. @
  377.  
  378.  
  379. 1.2
  380. log
  381. @Fixed getpwent() to ignore blank lines.
  382. @
  383. text
  384. @d2 14
  385. a15 3
  386.  * Copyright (c) 1984 Regents of the University of California.
  387.  * All rights reserved.  The Berkeley software License Agreement
  388.  * specifies the terms and conditions for redistribution.
  389. d19 2
  390. a20 2
  391. static char sccsid[] = "@@(#)getpwent.c    5.2 (Berkeley) 3/9/86";
  392. #endif LIBC_SCCS and not lint
  393. d22 2
  394. d28 5
  395. a32 4
  396. static char EMPTY[] = "";
  397. static FILE *pwf = NULL;
  398. static char line[BUFSIZ+1];
  399. static struct passwd passwd;
  400. d34 101
  401. a134 6
  402. /*
  403.  * The following are shared with getpwnamuid.c
  404.  */
  405. char    *_pw_file = "/etc/passwd";
  406. DBM    *_pw_db;
  407. int    _pw_stayopen;
  408. d138 1
  409. a138 4
  410.     if (pwf == NULL)
  411.         pwf = fopen(_pw_file, "r");
  412.     else
  413.         rewind(pwf);
  414. d141 10
  415. d153 1
  416. a153 5
  417.     if (pwf != NULL) {
  418.         fclose(pwf);
  419.         pwf = NULL;
  420.     }
  421.     if (_pw_db != (DBM *)0) {
  422. d155 4
  423. a158 2
  424.         _pw_db = (DBM *)0;
  425.         _pw_stayopen = 0;
  426. d162 3
  427. a164 3
  428. static char *
  429. pwskip(p)
  430. register char *p;
  431. d166 1
  432. a166 5
  433.     while (*p && *p != ':' && *p != '\n')
  434.         ++p;
  435.     if (*p)
  436.         *p++ = 0;
  437.     return(p);
  438. d169 2
  439. a170 2
  440. struct passwd *
  441. getpwent()
  442. d172 3
  443. a174 1
  444.     register char *p;
  445. d176 2
  446. a177 2
  447.     if (pwf == NULL) {
  448.         if ((pwf = fopen( _pw_file, "r" )) == NULL)
  449. d179 29
  450. d209 25
  451. a233 3
  452.     for (;;) {
  453.         p = fgets(line, BUFSIZ, pwf);
  454.         if (p == NULL)
  455. d235 18
  456. a252 28
  457.         /* skip leading white space */
  458.         while (*p == ' ' || *p == '\t' || *p == '\n') {
  459.         ++p;
  460.         }
  461.         /* check and make sure this line is not blank */
  462.         if (strlen(p) == 0) {
  463.         continue;
  464.         }
  465.         passwd.pw_name = p;
  466.         p = pwskip(p);
  467.         passwd.pw_passwd = p;
  468.         p = pwskip(p);
  469.         passwd.pw_uid = atoi(p);
  470.         p = pwskip(p);
  471.         passwd.pw_gid = atoi(p);
  472.         passwd.pw_quota = 0;
  473.         passwd.pw_comment = EMPTY;
  474.         p = pwskip(p);
  475.         passwd.pw_gecos = p;
  476.         p = pwskip(p);
  477.         passwd.pw_dir = p;
  478.         p = pwskip(p);
  479.         passwd.pw_shell = p;
  480.         while (*p && *p != '\n')
  481.         p++;
  482.         *p = '\0';
  483.         return(&passwd);
  484.     }
  485. d255 2
  486. a256 2
  487. setpwfile(file)
  488.     char *file;
  489. d258 28
  490. a285 1
  491.     _pw_file = file;
  492. @
  493.  
  494.  
  495. 1.1
  496. log
  497. @Initial revision
  498. @
  499. text
  500. @d68 3
  501. a70 2
  502.     p = fgets(line, BUFSIZ, pwf);
  503.     if (p == NULL)
  504. d72 24
  505. a95 16
  506.     passwd.pw_name = p;
  507.     p = pwskip(p);
  508.     passwd.pw_passwd = p;
  509.     p = pwskip(p);
  510.     passwd.pw_uid = atoi(p);
  511.     p = pwskip(p);
  512.     passwd.pw_gid = atoi(p);
  513.     passwd.pw_quota = 0;
  514.     passwd.pw_comment = EMPTY;
  515.     p = pwskip(p);
  516.     passwd.pw_gecos = p;
  517.     p = pwskip(p);
  518.     passwd.pw_dir = p;
  519.     p = pwskip(p);
  520.     passwd.pw_shell = p;
  521.     while (*p && *p != '\n')
  522. d97 3
  523. a99 2
  524.     *p = '\0';
  525.     return(&passwd);
  526. @
  527.